package Servicio;

import Model.Caja; 
import Model.Congreso; 
import Model.Pedido; 
import Model.Usuario; 
import Model.Cliente;
import Model.Detalle;
import Model.Gasto;
import Model.Ingreso;
import Model.Permiso;
import Model.Reposicion;
import Model.VentasXCongreso;
import Model.Moneda;
import Model.VentasXMes;
import java.util.*;
//import java.lang.Object;




public class Proxy {

   static ArrayList<Congreso> ArrayCongresos=null;
   static ArrayList<Congreso> ArrayCongresosConEnvios=null;
   static ArrayList<Pedido> obtenerEnvios=null;
   static ArrayList<String> obtenerApellidos=null;
   static ArrayList<Cliente> obtenerClientes=null;
   static ArrayList<Cliente> obtenerClientesNuevos=null;
   static ArrayList<Permiso> obtenerPermisos=null;
   static ArrayList<Usuario> obtenerUsuarios=null;
   static ArrayList<Moneda> obtenerMonedas=null;
    public Proxy () {
        }
    
    public static int inicializarProxy(){
        if (ArrayCongresosConEnvios==null){
            ArrayCongresosConEnvios=Facade.obtenerCongresosConEnvios();
            return 90;}
        if (ArrayCongresos==null){
            ArrayCongresos=Facade.obtenerCongresos();
            return 76;}
        if (obtenerEnvios==null){
            obtenerEnvios=Facade.obtenerEnvios();
            return 60;}
        if (obtenerApellidos==null){
            obtenerApellidos=Facade.obtenerApellidos();
            return 50;}
        if (obtenerClientes==null){
            obtenerClientes=Facade.obtenerClientes();
            return 30;}
        if (obtenerClientesNuevos==null){
            obtenerClientesNuevos=Facade.obtenerClientesNuevos();
            return 20;}
        if (obtenerPermisos==null){
            obtenerPermisos=Facade.obtenerPermisos();
            return 10;}
        if (obtenerUsuarios==null){
            obtenerUsuarios=Facade.obtenerUsuarios();
            return 0;}
        return 0;
    
    }
public static void Recargar(){

            ArrayCongresosConEnvios=Facade.obtenerCongresosConEnvios();
            ArrayCongresos=Facade.obtenerCongresos();
            obtenerEnvios=Facade.obtenerEnvios();
            obtenerPermisos=Facade.obtenerPermisos();
            obtenerUsuarios=Facade.obtenerUsuarios();
    }
    /** Obtiene un congreso a partir de su clave primaria*/ 
    public static Congreso obtenerCongreso (String iniciales, String fechaInicio) {
       for (int i=0;ArrayCongresos.size()>i ;i++){
           if (ArrayCongresos.get(i).getIniciales().compareTo(iniciales)==0 && ArrayCongresos.get(i).getFechaInicio().compareTo(fechaInicio)==0)
               return ArrayCongresos.get(i);
       }
        
        return Facade.obtenerCongreso(iniciales, fechaInicio);
    }

    /** Obtiene un arreglo con todos los congresos (Sin pedidos)*/
    public  static ArrayList<Congreso> obtenerCongresos() {
      return ArrayCongresos;
    }
    
    /** Obtiene un arreglo con todos los congresos (Sin pedidos) para la importacion*/
    public static ArrayList<Congreso> obtenerCongresosViejos() {
        return Facade.obtenerCongresosViejos();
    }
    
    public static ArrayList<Congreso> obtenerCongresosNuevos() {
      return Facade.obtenerCongresosNuevos();
    }
    
    /** Obtiene un arreglo con todos los congresos que tiene envios a realizar (Sin pedidos)*/
    public static  ArrayList<Congreso> obtenerCongresosConEnvios() {
      return ArrayCongresosConEnvios;
    }
    
    /**Obtiene todos los envios*/
    public static ArrayList<Pedido> obtenerEnvios () {
        return obtenerEnvios;
    }
    
    /** Obtiene el tren de copiado*/    
    public static void obtenerTren(ArrayList<String> dvds,ArrayList<String> cantidad, Congreso cong) {
        Facade.obtenerTren(dvds, cantidad, cong);  
    }
    
  /** Obtiene diferentes conjuntos expandibles que hay */
    public static ArrayList<String> obtenerConjuntoExpandible (int tipo) {
       return Facade.obtenerConjuntoExpandible(tipo);
    }
    
    /** Obtiene un arreglo con todos los apellidos de los clientes*/
    public static ArrayList<String> obtenerApellidos(){
        return obtenerApellidos;
    }
    
   /**Obtiene a todos los clientes */ 
    public static ArrayList<Cliente> obtenerClientes () {
        return obtenerClientes;
    }
    
    /**Obtiene todas las monedas que existen */
    public static ArrayList<Moneda> obtenerMonedas() {
        return obtenerMonedas;
    }
    
    /**Obtiene a todos los clientes que no tienen pedidos */ 
    public static ArrayList<Cliente> obtenerClientesNuevos () {
        return obtenerClientesNuevos;
    }

   /** Obtiene todos los pedidos de un congreso junto con su cliente asociado */
    public static Congreso obtenerPedidos (Congreso cong) {
        //if (cong.getPedido() == null || cong.getPedido().size()==0)
            cong.setPedido(Facade.obtenerPedidos(cong));
        return cong;
      
    }
    
    /** Obtiene todos los pedidos de un una Caja junto con su cliente asociado */
    public static ArrayList<Pedido> obtenerPedidosCaja (Congreso cong) {
        return Facade.obtenerPedidosCaja(cong);
    }

    /** Obtiene la caja de un congreso determinado junto con su arreglo de Gastos y de ingresos*/ 
    public static Caja obtenerCaja (Congreso cong) {
        return Facade.obtenerCaja(cong);
    }

    public static boolean eliminaGasto(String val){
        return Facade.eliminaGasto(val);
    }
    
    public static boolean eliminaIngreso(String val){
        return Facade.eliminaIngreso(val);
    }
/** Devuelve el usuario y sus permisos (si existe, sino devuelve nulo)*/
    public static Usuario validarUsuario (String nombreUsuario, String password) {
        return Facade.validarUsuario(nombreUsuario, password);
    }
  
 /**Obtiene todos los permisos disponibles*/   
    public static ArrayList<Permiso> obtenerPermisos(){
        return obtenerPermisos;
    }
  
  /**Obtiene todos los usuarios con sus permisos correspondientes*/ 
    public static ArrayList<Usuario> obtenerUsuarios(){
        return obtenerUsuarios;
    }
      
    //Devuelve los detalles (estadisticas) de un Cliente, o nulo si no existe    
    public static Detalle detallesCliente(Cliente cliente){
        return Facade.detallesCliente(cliente);
    }
    
  //Devuelve los detalles (estadisticas) de todos los clientes    
    public static ArrayList<Detalle> detallesCliente(){
        return Facade.detallesCliente();
    }
    
  //Devuelve las ventas por mes    
    public static ArrayList<VentasXMes> obtenerVentasXMes(){
        return Facade.obtenerVentasXMes();
    }
    
  //Devuelve las ventas por Congreso    
    public static ArrayList<VentasXCongreso> obtenerVentasXCongreso(){
        return Facade.obtenerVentasXCongreso();
    }

    /**Almacena al Pedido junto con el cliente*/ 
    public static boolean almacenarPedido (Pedido pedido) {
        if (pedido.getEnvio().compareTo("si")==0 || pedido.getEnvio().compareTo("1")==0 )
            obtenerEnvios.add(pedido);
       // JOptionPane.showMessageDialog(new JFrame(), "Debe ingresar "+pedido.getCongreso().getPedido().size(), "Atención", JOptionPane.WARNING_MESSAGE);
        pedido.getCongreso().getPedido().add(pedido);
        //JOptionPane.showMessageDialog(new JFrame(), "Debe ingresar "+pedido.getCongreso().getPedido().size(), "Atención", JOptionPane.WARNING_MESSAGE);
        return Facade.almacenarPedido(pedido);
    }

    /** Modifica el estado de un pedido */
    public static void modificarPedido (Pedido pedido) {
        Facade.modificarPedido(pedido);
    }
/** Modifica el saldo inicial de la caja de un congreso*/
    public static void modificarSaldoIni (Congreso cong) {
        Facade.modificarSaldoIni(cong);
    }

/** Agrega un Gasto al a Caja de un Congreso */  
    public static void modificarGasto (Congreso cong, Gasto gasto) {
        Facade.modificarGasto(cong, gasto);
    }
    
    /** Agrega un Ingreso al a Caja de un Congreso */  
    public static void modificarIngreso (Congreso cong, Ingreso ingreso) {
        Facade.modificarIngreso(cong, ingreso);
    }
    
    public static void agregarExtraccion(Congreso cong, Ingreso ingreso) {
        Facade.agregarExtraccion(cong, ingreso);
    }
    
    public static void agregarAdelanto(Congreso cong, Ingreso ingreso) {
        Facade.agregarAdelanto(cong, ingreso);
    }
    
/** Actualiza la contraseña del usuario*/    
    public static void cambiarPass(Usuario usuario) {
        Facade.cambiarPass(usuario);        
    }
 
 /** Almacena un nuevo congreso junto con su caja asociada*/
    public static boolean almacenarCongreso (Congreso congreso) {
             ArrayCongresos.add(0,congreso);
             return Facade.almacenarCongreso(congreso);
    }
     /** Almacena una reposicion de stock*/
    public static boolean almacenarReposicion(Reposicion rep) {
             return Facade.almacenarReposicion(rep);
    }
 /**Modifica en la base de datos el estado nuevo del congreso (eliminado o inactivo)*/   
    public static void modificarCongreso(Congreso congreso){
        ManejadorCongreso creador = new ManejadorCongreso();
        creador.update(congreso);
    }

     /**Almacena al usuario con sus permisos correspondientes*/  
    public static boolean almacenarUsuario(Usuario usuario){
            obtenerUsuarios.add(usuario);
            return Facade.almacenarUsuario(usuario);
    }

     /**Elimina al usuario y a sus permisos asociados de la base de datos*/  
    public static void eliminarUsuario(Usuario usuario){
        Facade.eliminarUsuario(usuario);
        obtenerUsuarios.remove(usuario);
    }
    
      /**Elimina el pedido y sus DVDs de la base de datos*/  
    public static void eliminarPedido(Pedido pedido){
        if(pedido.getCongreso().getPedido()!=null)
            pedido.getCongreso().getPedido().remove(pedido);
        Facade.eliminarPedido(pedido);                
    }
  
 /**Los permisos del usuario son los nuevos*/   
    public static void modificarUsuario(Usuario usuario){
        Facade.modificarUsuario(usuario);
    }
   public static boolean almacenarCliente(Cliente cliente){
       obtenerClientesNuevos.add(cliente);
       obtenerApellidos.add(cliente.getApellidoCli());
       obtenerClientes.add(cliente);
       return Facade.almacenarCliente(cliente);
   }
}

